package be.ipl.diapero.testUcc;

import static org.junit.Assert.*;

import java.util.GregorianCalendar;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.junit.Before;
import org.junit.Test;

import be.ipl.diapero.domaine.Joueur;
import be.ipl.diapero.domaine.Partie;
import be.ipl.diapero.exceptions.ArgumentInvalideException;
import be.ipl.diapero.ucc.GestionJoueur;
import be.ipl.diapero.ucc.GestionPartie;

public class TestGestionPartie {

	private static GestionPartie gp;	
	private Partie partie ;
	private Partie maPartie;
	private Partie maPartie2;
	private Partie maPartie3;
	private Partie maPartieCommencer ;
	private Partie maPartieEnAttente ;
	private Partie maPartieTerminee ;
	private Partie partieTemp ;
	private Joueur joueur ;
	
	@Before
	public void setUp() throws Exception {
		try {
			Context jndi = new InitialContext();
			gp = (GestionPartie) jndi
					.lookup("ejb:diaperoEAR/diapero/GestionPartieImpl!be.ipl.diapero.ucc.GestionPartie");
		} catch (NamingException e) {
			e.printStackTrace();
		}
		
		partieTemp = new Partie("partie6", new GregorianCalendar());
		joueur = new Joueur("eric", "1234");
	}
	
	// creationPartie 
	
	@Test	
	public void testCreationPartieValide() throws ArgumentInvalideException {
	     partie = this.gp.creerPartie("partie1");
	     assertNotNull(partie);
	}	
	
	@Test(expected = ArgumentInvalideException.class)	
	public void testCreationPartieNomVide() throws ArgumentInvalideException {
	     this.gp.creerPartie("");
	}
	
	@Test	
	public void testCreationPartieExistante() throws ArgumentInvalideException {
	     assertNull(this.gp.creerPartie(partie.getNom()));
	}	
	
	
	// commencerPartie
	
	@Test	
	public void testCommencerPartieInvalide() throws ArgumentInvalideException {
		maPartieCommencer = new Partie("maPartieCommencer", new GregorianCalendar());
		this.gp.creerPartie(maPartieCommencer.getNom());
		assertFalse(this.gp.commencerPartie(maPartieCommencer));
	}	
	
	@Test	
	public void testCommencerPartieValide() throws ArgumentInvalideException {
		this.gp.rejoindrePartie(maPartieCommencer, new Joueur("Kiki", "1234"));
		assertTrue(this.gp.rejoindrePartie(maPartieCommencer, new Joueur("Antoine", "1234")));
		
	}	
	
	// annulerPartie
	
	@Test	
	public void testAnnulationPartieExistante(){
	     assertTrue((this.gp.annulerPartie(partie)));
	}	
	
	@Test	
	public void testAnnulationPartieInexistante(){
	     assertFalse((this.gp.annulerPartie(partieTemp)));
	}	
	
	
	// rejoindrePartie
	
	@Test	
	public void testRejoindrePartieInexistante(){
	     assertFalse((this.gp.rejoindrePartie(partieTemp, joueur)));
	}	
	
	@Test	
	public void testRejoindrePartieExistante() throws ArgumentInvalideException{
		 maPartie = new Partie("maPartie", new GregorianCalendar());
		 this.gp.creerPartie(maPartie.getNom());
	     assertTrue((this.gp.rejoindrePartie(maPartie, joueur)));
	}	
	
	
	// estEnCours
	
	@Test	
	public void testEstEnCoursValide(){
	     assertTrue((this.gp.estEnCours(maPartie)));
	}	
	
	@Test	
	public void testEstEnCoursInvalide(){
	     assertFalse((this.gp.estEnCours(partieTemp)));
	}	
	
	// getJoueursGemmes
	
	@Test	
	public void testGetJoueursGemmes(){
	     assertNotNull((this.gp.getJoueursGemmes(maPartie)));
	}	
	
	
	// getVainqueur
	
	@Test	
	public void testGetVainqueur(){
	     assertNotNull((this.gp.getVainqueur(maPartie)));
	}	
	
	// listerJoueurs
	
	@Test	
	public void testListerJoueurs(){
	     assertNotNull((this.gp.listerJoueurs(maPartie)));
	}	
	
	// listerParties
	
	@Test	
	public void tesListerParties() throws ArgumentInvalideException{
		 maPartie2 = new Partie("maPartie2", new GregorianCalendar());
		 maPartie3 = new Partie("maPartie3", new GregorianCalendar());
		 this.gp.creerPartie(maPartie2.getNom());
		 this.gp.creerPartie(maPartie3.getNom());
		 this.gp.rejoindrePartie(maPartie2, new Joueur("Kevin", "1234"));
		 this.gp.rejoindrePartie(maPartie2, new Joueur("Mimi", "1234"));
		 this.gp.rejoindrePartie(maPartie3, new Joueur("Panini", "1234"));
		 this.gp.rejoindrePartie(maPartie3, new Joueur("Arcer", "1234"));
		
	     assertNotNull((this.gp.listerJoueurs(maPartie2)));
	     assertNotNull((this.gp.listerJoueurs(maPartie3)));
    
	}	
	
	// listerPartiesEnAttente
	
	@Test	
	public void testListerPartiesEnAttente() throws ArgumentInvalideException{
		maPartieEnAttente = new Partie("maPartieEnAttente", new GregorianCalendar());
		this.gp.creerPartie(maPartieEnAttente.getNom());
	     assertNotNull((this.gp.listerPartiesEnAttente()));
	}	
	
	// TerminerPartie
	
	@Test	
	public void testTerminerPartie() throws ArgumentInvalideException{
		 maPartieTerminee = new Partie("maPartieTerminee", new GregorianCalendar());
		 this.gp.creerPartie(maPartieTerminee.getNom());
		 this.gp.rejoindrePartie(maPartieTerminee, new Joueur("Keke", "1234"));
		 this.gp.rejoindrePartie(maPartieTerminee, new Joueur("Killian", "1234"));
		 assertTrue(this.gp.terminerPartie(maPartieTerminee));
	}	
	
	
	
	// listerPartiesTerminees
	
	@Test	
	public void testListerPartiesTerminees() throws ArgumentInvalideException{
	     assertNotNull((this.gp.listerPartiesTerminees()));
	}	
	
	
	// listerPartiesEnCours
	
	@Test	
	public void testListerPartiesEnCours() {
	     assertNotNull((this.gp.listerPartiesEnCours()));
	}	
	
	
	// rechercherPartie
	
	@Test	
	public void testRechercherPartie() {
	     assertNotNull((this.gp.rechercherPartie(maPartie2.getId())));
	}	
	
	
	// tourSuivant
	
	@Test	
	public void testTourSuivant() {
	     assertNotNull((this.gp.tourSuivant(maPartie3)));
	}	
	
	
	
	
	
	

}
